{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Algorithm TD3\n",
    "****\n",
    "Initialize critic networks $Q_{\\theta_1},Q_{\\theta_2}$，and actor network $\\pi_\\phi$<br>\n",
    "with random parameters $\\theta_1, \\theta_2,\\phi$<br>\n",
    "Initialize target networks $\\theta'_1 \\leftarrow \\theta_1,\\theta'_2 \\leftarrow \\theta_2, \\phi' \\leftarrow \\phi$<br>\n",
    "Initialize replay buffer $B$<br>\n",
    "**for** t = 1 **to** $T$ **do**<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;Select action with exploration noise $a \\sim \\pi_\\phi(s) + \\epsilon \\;,\\;\\epsilon \\sim N(0,\\sigma)$ and observe reward $r$ and new state $s'$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;Store transition tuple ($s,a,r,s'$) in $B$<br><br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;Sample mini-batch of $N$ transitions ($s,a,r,s'$) from $B$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;$\\tilde{a}\\leftarrow \\pi_{\\phi'}(s') + \\epsilon,\\quad \\epsilon \\sim clip(N(0,\\tilde{\\sigma}),-c,c)$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;$y \\leftarrow r + \\gamma min_{i=1,2}Q_{\\theta'_i}(s',\\tilde{a})$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;Update critics $\\theta_i \\leftarrow argmin_{\\theta_i}N^{-1}\\sum(y-Q_{\\theta_i}(s,a))^2$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;**if** t mod d **then**<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Update $\\phi$ by the deterministic policy gradient:<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$\\nabla_\\phi J(\\phi)=N^{-1}\\sum\\nabla_aQ_{\\theta_1}(s,a)|_{a=\\pi_\\phi (s)}\\nabla_\\phi\\pi_\\phi(s)$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Update target networks:<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$\\theta'_i \\leftarrow \\tau\\theta_i + (1-\\tau)\\theta'_i \\quad i=1,2$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$\\phi' \\leftarrow \\tau\\phi +(1-\\tau)\\phi'$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;**end if**<br>\n",
    "**end if**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 与DDPG相比的三个tricks\n",
    "1. 使用了两个Q-learning网络，选择TD_error较小的更新Q现实网络\n",
    "2. 延迟更新Policy网络,Value网络的更新速度是Policy的两倍(论文中推荐的超参)。并且在更新Policy网络时再更新三个target网络\n",
    "3. 在target_policy选择动作时增加高斯噪声并且clip，以此来减少Q function的error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "暂定为Noise的问题:之前是使用pytorch的Normal生成噪声，现在改用OUNoise类生成"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.distributions import Normal\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns; sns.set(color_codes=True)\n",
    "import torch.nn.functional as F\n",
    "import torchviz\n",
    "from IPython.display import clear_output\n",
    "import pdb\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, buffer_size, batch_size, column):\n",
    "        self.current_state = np.zeros((buffer_size, column), dtype=np.float32)\n",
    "        self.action = np.zeros(buffer_size, dtype=np.float32)\n",
    "        self.next_state = np.zeros((buffer_size, column), dtype=np.float32)\n",
    "        self.reward = np.zeros(buffer_size, dtype=np.float32)\n",
    "        self.done = np.zeros(buffer_size, dtype=np.float32)\n",
    "        self.batch_size = batch_size\n",
    "        self.buffer_size = buffer_size\n",
    "        self.size, self.current_index = 0, 0\n",
    "    \n",
    "    def store(self, current_state, action, next_state, reward, done):\n",
    "        self.current_state[self.current_index] = current_state\n",
    "        # pdb.set_trace()\n",
    "        self.action[self.current_index] = action\n",
    "        self.next_state[self.current_index] = next_state\n",
    "        self.reward[self.current_index] = reward\n",
    "        self.done[self.current_index] = done\n",
    "        self.size = min((self.size + 1), buffer_size)\n",
    "        self.current_index = (self.current_index + 1) % self.buffer_size\n",
    "    \n",
    "    def sample(self):\n",
    "        idx = np.random.choice(self.size, self.batch_size, replace=False)\n",
    "        return dict(current_state = torch.FloatTensor(self.current_state[idx]).to(device),\n",
    "                    action = torch.FloatTensor(self.action[idx]).unsqueeze(1).to(device),\n",
    "                    next_state = torch.FloatTensor(self.next_state[idx]).to(device),\n",
    "                    reward = torch.FloatTensor(self.reward[idx]).unsqueeze(1).to(device),\n",
    "                    done = torch.FloatTensor(self.done[idx]).unsqueeze(1).to(device))\n",
    "    \n",
    "    def __len__(self):\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "# 使用确定性策略，对action增加噪声\n",
    "class OUNoise:\n",
    "    def __init__(self, action_space, mu=0.5, theta=0.15, max_sigma=0.3, min_sigma=0.1, decay_period=1000000):\n",
    "        self.mu = mu\n",
    "        self.theta = theta\n",
    "        self.sigma = max_sigma\n",
    "        self.max_sigma = max_sigma\n",
    "        self.min_sigma = min_sigma\n",
    "        self.decay_period = decay_period\n",
    "        self.action_dim = action_space.shape[0]\n",
    "        self.low = action_space.low\n",
    "        self.high = action_space.high\n",
    "        # get 定义立即执行函数\n",
    "        self.reset()\n",
    "    \n",
    "    def reset(self):\n",
    "        self.state = np.ones(self.action_dim) * self.mu\n",
    "    \n",
    "    def evolve_state(self):\n",
    "        # self.state += [0.0] + 0.3 * np.random.randn(1)\n",
    "        self.state = self.state + self.theta * (self.mu - self.state)\\\n",
    "                    +np.random.randn(self.action_dim) * self.sigma * np.sqrt(0.01) \n",
    "        return self.state\n",
    "    \n",
    "    def get_action(self, action, t=0):\n",
    "        self.sigma = self.max_sigma - (self.max_sigma - self.min_sigma) * min(1.0, t / self.decay_period)\n",
    "        return np.clip(action + self.evolve_state(), self.low, self.high)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ou_noise = OUNoise(env.action_space)\n",
    "# action = [ou_noise.evolve_state() for _ in range(100)]\n",
    "# plt.plot(action)\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NormalizeActions(gym.ActionWrapper):\n",
    "    \n",
    "    def __init__(self, env):\n",
    "        super(NormalizeActions, self).__init__(env)\n",
    "        self.low_bound = self.action_space.low # -2\n",
    "        self.upper_bound = self.action_space.high # +2\n",
    "        \n",
    "    def action(self, action):\n",
    "        # 神经网络使用 tanh 输出的动作在 -1 ~ +1 之间，其实在forward()中乘上2就好了，没必要这么复杂\n",
    "        action = self.low_bound + (action + 1.0) * 0.5 * (self.upper_bound - self.low_bound) # action * 2\n",
    "        action = np.clip(action, self.low_bound, self.upper_bound)\n",
    "        \n",
    "        return action\n",
    "    \n",
    "    def reverse_action(self, action):\n",
    "        # 对 action 进行反转(reverse)，\n",
    "        action = 2 * (action - self.low_bound) / (self.upper_bound - self.low_bound) - 1 # action / 2\n",
    "        action = np.clip(action, self.low_bound, self.upper_bound)\n",
    "        \n",
    "        return actions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Critic(nn.Module):\n",
    "    def __init__(self, state_dim, action_dim):\n",
    "        super(Critic, self).__init__()\n",
    "        \n",
    "        self.first_critic = nn.Sequential(\n",
    "                nn.Linear(state_dim + action_dim, 128),\n",
    "                nn.ReLU(),\n",
    "                nn.Linear(128, 32),\n",
    "                nn.ReLU(),\n",
    "                nn.Linear(32, 1)\n",
    "        )\n",
    "        \n",
    "        self.second_critic = nn.Sequential(\n",
    "                nn.Linear(state_dim + action_dim, 32),\n",
    "                nn.ReLU(),\n",
    "                nn.Linear(32, 16),\n",
    "                nn.ReLU(),\n",
    "                nn.Linear(16, 1)\n",
    "        )\n",
    "        \n",
    "    def forward(self, state, action):\n",
    "        data_cat = torch.cat((state, action), dim=1)\n",
    "        # data_norm = (data_cat - data_cat.mean())/data_cat.std()\n",
    "        first_value = self.first_critic(data_cat)\n",
    "        second_value = self.second_critic(data_cat)\n",
    "        return first_value, second_value\n",
    "\n",
    "    def first_Q(self, state, action):\n",
    "        data_cat = torch.cat((state, action), dim=1)\n",
    "        data_norm = (data_cat - data_cat.mean())/data_cat.std()\n",
    "        first_value = self.first_critic(data_norm)\n",
    "        return first_value\n",
    "\n",
    "# class Critic(nn.Module):\n",
    "#     def __init__(self, state_dim, action_dim):\n",
    "#         super(Critic, self).__init__()\n",
    "#         self.linear_state = nn.Linear(state_dim, 64)\n",
    "#         self.linear_action = nn.Linear(action_dim, 64)\n",
    "#         self.linear2 = nn.Linear(128, 32)\n",
    "#         self.linear3 = nn.Linear(32, 1)\n",
    "        \n",
    "#     def forward(self, state, action):\n",
    "#         hidden_state = F.relu(self.linear_state(state))\n",
    "#         hidden_action = F.relu(self.linear_action(action))\n",
    "#         cat_state_action = torch.cat((hidden_action, hidden_state), dim=1)\n",
    "#         hidden2 = F.relu(self.linear2(cat_state_action))\n",
    "#         Q = self.linear3(hidden2)\n",
    "#         return Q\n",
    "    \n",
    "class Actor(nn.Module):\n",
    "    def __init__(self, in_dim, out_dim):\n",
    "        super(Actor, self).__init__()\n",
    "        \n",
    "        self.actor_network = nn.Sequential(\n",
    "                nn.Linear(in_dim, 32),\n",
    "                nn.ReLU(),\n",
    "                nn.Linear(32, 16),\n",
    "                nn.ReLU(),\n",
    "                nn.Linear(16, out_dim)\n",
    "        )\n",
    "    \n",
    "    def forward(self, state): \n",
    "        # data_norm = (state - state.mean())/state.std()\n",
    "        action = torch.tanh(self.actor_network(state)) # 匹配动作空间\n",
    "        return action\n",
    "    \n",
    "#     def get_action(self, state):\n",
    "#         state = torch.FloatTensor(state).unsqueeze(0).to(device)\n",
    "#         action = self.forward(state)\n",
    "#         return action.detach().item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "def td3_train(step, gamma=0.99, soft_tau=1e-2, noise_clip=0.3):\n",
    "    actor_loss = None\n",
    "    \n",
    "    samples = replay_buffer.sample()\n",
    "    state, action, next_state = samples[\"current_state\"], samples[\"action\"], samples[\"next_state\"]\n",
    "    reward, done = samples[\"reward\"], samples[\"done\"]\n",
    "    \n",
    "    next_action = target_actor_network(next_state)\n",
    "    \n",
    "    # next_action = torch.FloatTensor(ou_noise.get_action(next_action.detach().cpu().numpy(), step)).to(device)\n",
    "    first_target_value, second_target_value = target_critic_network(next_state, next_action)\n",
    "    target_value = reward + (1.0-done) * gamma * torch.min(first_target_value, second_target_value)\n",
    "    first_value, second_value = critic_network(state, action)\n",
    "    critic_loss = F.mse_loss(target_value.detach(), first_value) + \\\n",
    "                    F.mse_loss(target_value.detach(), second_value)\n",
    "    \n",
    "#     target_value = reward + (1.0-done) * gamma * target_critic_network(next_state, target_actor_network(next_state))\n",
    "#     value = critic_network(state, actor_network(state))\n",
    "#     critic_loss = (value - target_value.detach()).pow(2).mean()\n",
    "    \n",
    "    critic_optimizer.zero_grad()\n",
    "    critic_loss.backward()\n",
    "    critic_optimizer.step()\n",
    "    \n",
    "    if step % 2 == 0:\n",
    "        actor_loss = -1.0 * critic_network.first_Q(state, actor_network(state)).mean()\n",
    "\n",
    "        actor_optimizer.zero_grad()\n",
    "        actor_loss.backward()\n",
    "        actor_optimizer.step()\n",
    "\n",
    "        actor_loss = actor_loss.item()\n",
    "\n",
    "        for target_param, param in zip(target_critic_network.parameters(), critic_network.parameters()):\n",
    "            target_param.data.copy_(target_param.data*(1.0-soft_tau) + param.data * soft_tau)\n",
    "        for target_param, param in zip(target_actor_network.parameters(), actor_network.parameters()):\n",
    "            target_param.data.copy_(target_param.data*(1.0-soft_tau) + param.data * soft_tau)\n",
    "    \n",
    "    return critic_loss.item(), actor_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def smooth_plot(factor, item, plot_decay):\n",
    "    item_x = np.arange(len(item))\n",
    "    item_smooth = [np.mean(item[i:i+factor]) if i > factor else np.mean(item[0:i+1])\n",
    "                  for i in range(len(item))]\n",
    "    for i in range(len(item)// plot_decay):\n",
    "        item_x = item_x[::2]\n",
    "        item_smooth = item_smooth[::2]\n",
    "    return item_x, item_smooth\n",
    "    \n",
    "def plot(episode, rewards, critic_losses, actor_losses):\n",
    "    clear_output(True)\n",
    "    rewards_x, rewards_smooth = smooth_plot(10, rewards, 200)\n",
    "    critic_losses_x, critic_losses_smooth = smooth_plot(10, critic_losses, 30000)\n",
    "    actor_losses_x, actor_losses_smooth = smooth_plot(10, actor_losses, 30000)\n",
    "    \n",
    "    plt.figure(figsize=(18, 12))\n",
    "    plt.subplot(311)\n",
    "    plt.title('episode %s. Reward: %s'%(episode, rewards_smooth[-1]))\n",
    "    plt.plot(rewards, label=\"Rewards\", color='lightsteelblue', linewidth='1')\n",
    "    plt.plot(rewards_x, rewards_smooth, label='Smothed_Rewards', color='darkorange', linewidth='3')\n",
    "    plt.legend(loc='best')\n",
    "    \n",
    "    plt.subplot(312)\n",
    "    plt.title('Critic_Losses')\n",
    "    plt.plot(critic_losses,label=\"Critic_Losses\",color='lightsteelblue',linewidth='1')\n",
    "    plt.plot(critic_losses_x, critic_losses_smooth, \n",
    "             label=\"Smoothed_Critic_Losses\",color='darkorange',linewidth='3')\n",
    "    plt.legend(loc='best')\n",
    "    \n",
    "    plt.subplot(313)\n",
    "    plt.title('Actor_Losses')\n",
    "    plt.plot(actor_losses,label=\"Actor_Losses\",color='lightsteelblue',linewidth='1')\n",
    "    plt.plot(actor_losses_x, actor_losses_smooth, \n",
    "             label=\"Smoothed_Actor_Losses\",color='darkorange',linewidth='3')\n",
    "    plt.legend(loc='best')\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "env = gym.make(\"Pendulum-v0\")\n",
    "# env = NormalizeActions(gym.make(\"MountainCarContinuous-v0\"))\n",
    "ou_noise = OUNoise(env.action_space)\n",
    "\n",
    "state_space = env.observation_space.shape[0]\n",
    "action_space = env.action_space.shape[0]\n",
    "high_action_space = env.action_space.high[0]\n",
    "low_action_space = env.action_space.low[0]\n",
    "\n",
    "critic_network = Critic(state_space, action_space).to(device)\n",
    "target_critic_network = Critic(state_space, action_space).to(device)\n",
    "actor_network = Actor(state_space, action_space).to(device)\n",
    "target_actor_network = Actor(state_space, action_space).to(device)\n",
    "\n",
    "target_critic_network.load_state_dict(critic_network.state_dict())\n",
    "target_actor_network.load_state_dict(actor_network.state_dict())\n",
    "\n",
    "critic_optimizer = optim.Adam(critic_network.parameters(), lr=1e-3)\n",
    "actor_optimizer = optim.Adam(actor_network.parameters(), lr=1e-4)\n",
    "\n",
    "buffer_size = 1000000\n",
    "batch_size = 128\n",
    "replay_buffer = ReplayBuffer(buffer_size, batch_size, state_space)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "code_folding": [],
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x864 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-9-8e614ef4ecf8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     16\u001b[0m         \u001b[0;31m# pdb.set_trace()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreplay_buffer\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0mbatch_size\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 18\u001b[0;31m                 \u001b[0mcritic_loss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mactor_loss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtd3_train\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     19\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mactor_loss\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     20\u001b[0m                     \u001b[0mcritic_losses\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcritic_loss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-6-a02053f73f0d>\u001b[0m in \u001b[0;36mtd3_train\u001b[0;34m(step, gamma, soft_tau, noise_clip)\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0mactor_loss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m     \u001b[0msamples\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mreplay_buffer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msample\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m     \u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maction\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnext_state\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msamples\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"current_state\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msamples\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"action\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msamples\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"next_state\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0mreward\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdone\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msamples\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"reward\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msamples\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"done\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-2-9fbf5fb9d6d7>\u001b[0m in \u001b[0;36msample\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     21\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     22\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0msample\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 23\u001b[0;31m         \u001b[0midx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mchoice\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbatch_size\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreplace\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     24\u001b[0m         return dict(current_state = torch.FloatTensor(self.current_state[idx]).to(device),\n\u001b[1;32m     25\u001b[0m                     \u001b[0maction\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mFloatTensor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maction\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0midx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munsqueeze\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "episodes = 3000\n",
    "steps = 1000\n",
    "sigma = 1\n",
    "target_sigma = 0.6\n",
    "critic_losses, actor_losses, all_rewards = [], [], []\n",
    "\n",
    "\n",
    "for episode in range(episodes):\n",
    "    state = env.reset()\n",
    "    episode_reward = 0\n",
    "    for step in range(steps):\n",
    "        action = actor_network(torch.FloatTensor(state).unsqueeze(0).to(device))\n",
    "        action = ou_noise.get_action(action.detach().item(), step)\n",
    "        next_state, reward, done, _ = env.step(action)\n",
    "        replay_buffer.store(state, action, next_state, reward, done)\n",
    "        # pdb.set_trace()\n",
    "        if len(replay_buffer) > batch_size :\n",
    "                critic_loss, actor_loss = td3_train(step)\n",
    "                if actor_loss is not None:\n",
    "                    critic_losses.append(critic_loss)\n",
    "                    actor_losses.append(actor_loss)\n",
    "        \n",
    "        state = next_state\n",
    "        episode_reward += reward\n",
    "        \n",
    "        if done:\n",
    "            break\n",
    "    \n",
    "    all_rewards.append(episode_reward)\n",
    "    plot(episode, all_rewards, critic_losses, actor_losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(actor_network.state_dict(), \"./model/TD3.pth\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "policy_net_1 = Actor(state_space, action_space)\n",
    "policy_net_1.load_state_dict(torch.load(\"./model/TD3.pth\"))\n",
    "policy_net_1.eval()\n",
    "\n",
    "import pdb\n",
    "import gym\n",
    "from IPython import display\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "env = gym.make('Pendulum-v0')\n",
    "state = env.reset()\n",
    "img = plt.imshow(env.render(mode='rgb_array')) # only call this once\n",
    "for _ in range(1000):\n",
    "    img.set_data(env.render(mode='rgb_array')) # just update the data\n",
    "    display.display(plt.gcf())\n",
    "    display.clear_output(wait=True)\n",
    "    \n",
    "    action = policy_net_1(torch.FloatTensor(state)).detach().numpy()\n",
    "    # action = env.action_space.sample()\n",
    "    next_state, _, done, _ = env.step(action)\n",
    "    if done: \n",
    "        state = env.reset()\n",
    "    state = next_state"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
